Answer

Rails applications commonly use Service Objects (business logic), Decorators (presentation), Form Objects (complex validations), Query Objects (complex queries), Policy Objects (authorization), Value Objects (immutable data), and Observers (side effects).

Short Answer:
- Service Objects: Encapsulate business logic (UserRegistration)
- Decorators: Add presentation logic to models (UserDecorator)
- Form Objects: Handle complex form validations
- Query Objects: Encapsulate complex database queries
- Policy Objects: Handle authorization logic (Pundit)
- Repository Pattern: Abstract data access
- Factory Pattern: Create test data, objects

Detailed Explanation

# ============================================
# PATTERN 1: Service Objects (Most Common)
# ============================================

# Problem: Fat controllers and models
# Solution: Extract business logic to service objects

# ❌ BAD: Fat controller
class UsersController < ApplicationController
  def create
    @user = User.new(user_params)

    if @user.save
      # Send welcome email
      UserMailer.welcome(@user).deliver_later

      # Create default settings
      @user.create_settings(theme: 'light', notifications: true)

      # Subscribe to newsletter
      NewsletterService.subscribe(@user.email)

      # Track analytics
      Analytics.track('user_signup', user_id: @user.id)

      # Award signup bonus
      @user.wallet.credit(10)

      redirect_to @user
    else
      render :new
    end
  end
end

# ✅ GOOD: Service object
# app/services/user_registration_service.rb
class UserRegistrationService
  attr_reader :user, :errors

  def initialize(params)
    @params = params
    @errors = []
  end

  def call
    ActiveRecord::Base.transaction do
      create_user
      return false unless user.persisted?

      setup_defaults
      subscribe_to_newsletter
      track_analytics
      award_signup_bonus
      send_welcome_email

      true
    end
  rescue => e
    @errors << e.message
    false
  end

  private

  def create_user
    @user = User.create(@params)
    @errors = @user.errors.full_messages unless @user.persisted?
  end

  def setup_defaults
    user.create_settings(theme: 'light', notifications: true)
  end

  def subscribe_to_newsletter
    NewsletterService.new(user.email).subscribe
  end

  def track_analytics
    Analytics.track('user_signup', user_id: user.id)
  end

  def award_signup_bonus
    user.wallet.credit(10, description: 'Signup bonus')
  end

  def send_welcome_email
    UserMailer.welcome(user).deliver_later
  end
end

# Controller (clean!)
class UsersController < ApplicationController
  def create
    service = UserRegistrationService.new(user_params)

    if service.call
      redirect_to service.user, notice: 'Welcome!'
    else
      @errors = service.errors
      render :new
    end
  end
end

# Alternative: Return result object
class UserRegistrationService
  Result = Struct.new(:success?, :user, :errors)

  def call
    # ... logic ...

    Result.new(true, user, [])
  rescue => e
    Result.new(false, user, [e.message])
  end
end

# Usage
result = UserRegistrationService.new(params).call

if result.success?
  redirect_to result.user
else
  @errors = result.errors
  render :new
end

# ============================================
# PATTERN 2: Decorators (Presentation Logic)
# ============================================

# Problem: View logic in models or views
# Solution: Decorator pattern (Draper gem)

# Gemfile
gem 'draper'

# app/decorators/user_decorator.rb
class UserDecorator < Draper::Decorator
  delegate_all  # Delegate all methods to model

  # Formatted name
  def full_name_with_title
    "#{object.title} #{object.first_name} #{object.last_name}"
  end

  # Avatar with fallback
  def avatar_url(size: :medium)
    if object.avatar.attached?
      h.rails_blob_url(object.avatar.variant(resize_to_limit: avatar_sizes[size]))
    else
      h.asset_path("default-avatar-#{size}.png")
    end
  end

  # Formatted date
  def joined_date
    object.created_at.strftime("%B %Y")
  end

  # Status badge HTML
  def status_badge
    h.content_tag :span, class: "badge badge-#{status_color}" do
      object.status.humanize
    end
  end

  # Bio with HTML
  def formatted_bio
    return h.content_tag(:p, "No bio yet", class: 'text-muted') if object.bio.blank?

    h.simple_format(object.bio)
  end

  # Social links
  def social_links
    links = []
    links << h.link_to(h.icon('twitter'), object.twitter_url) if object.twitter_url?
    links << h.link_to(h.icon('github'), object.github_url) if object.github_url?
    h.safe_join(links, ' ')
  end

  private

  def avatar_sizes
    { small: [50, 50], medium: [200, 200], large: [800, 800] }
  end

  def status_color
    case object.status
    when 'active' then 'success'
    when 'inactive' then 'secondary'
    when 'suspended' then 'danger'
    else 'primary'
    end
  end
end

# Controller
class UsersController < ApplicationController
  def show
    @user = User.find(params[:id]).decorate
  end
end

# View
<div class="user-profile">
  <%= image_tag @user.avatar_url(size: :large) %>
  <h1><%= @user.full_name_with_title %></h1>
  <p>Member since <%= @user.joined_date %></p>
  <%= @user.status_badge %>
  <%= @user.formatted_bio %>
  <%= @user.social_links %>
</div>

# Collection decorator
users = User.all.decorate

# ============================================
# PATTERN 3: Form Objects (Complex Forms)
# ============================================

# Problem: Complex forms with validations across multiple models
# Solution: Form objects

# app/forms/event_registration_form.rb
class EventRegistrationForm
  include ActiveModel::Model
  include ActiveModel::Attributes

  # Define attributes
  attribute :event_id, :integer
  attribute :user_id, :integer
  attribute :ticket_type, :string
  attribute :guests_count, :integer, default: 0
  attribute :dietary_requirements, :string
  attribute :payment_method, :string

  # Validations
  validates :event_id, :user_id, :ticket_type, :payment_method, presence: true
  validates :guests_count, numericality: { greater_than_or_equal_to: 0, less_than: 10 }
  validates :ticket_type, inclusion: { in: %w[general vip] }

  validate :event_has_capacity
  validate :user_not_already_registered

  def save
    return false unless valid?

    ActiveRecord::Base.transaction do
      create_registration
      process_payment
      send_confirmation
      true
    end
  rescue => e
    errors.add(:base, e.message)
    false
  end

  def total_amount
    ticket_price * (1 + guests_count)
  end

  private

  def create_registration
    @registration = Registration.create!(
      event_id: event_id,
      user_id: user_id,
      ticket_type: ticket_type,
      guests_count: guests_count,
      dietary_requirements: dietary_requirements
    )
  end

  def process_payment
    PaymentService.new(
      user_id: user_id,
      amount: total_amount,
      payment_method: payment_method
    ).process!
  end

  def send_confirmation
    RegistrationMailer.confirmation(@registration).deliver_later
  end

  def event_has_capacity
    event = Event.find_by(id: event_id)
    return unless event

    if event.remaining_capacity < (1 + guests_count)
      errors.add(:base, 'Event is full')
    end
  end

  def user_not_already_registered
    if Registration.exists?(event_id: event_id, user_id: user_id)
      errors.add(:base, 'Already registered')
    end
  end

  def ticket_price
    event = Event.find(event_id)
    ticket_type == 'vip' ? event.vip_price : event.general_price
  end
end

# Controller
class RegistrationsController < ApplicationController
  def create
    @form = EventRegistrationForm.new(registration_params)

    if @form.save
      redirect_to event_path(@form.event_id), notice: 'Registered successfully!'
    else
      render :new
    end
  end

  private

  def registration_params
    params.require(:registration).permit(
      :event_id, :ticket_type, :guests_count, 
      :dietary_requirements, :payment_method
    ).merge(user_id: current_user.id)
  end
end

# ============================================
# PATTERN 4: Query Objects (Complex Queries)
# ============================================

# Problem: Complex queries scattered across controllers
# Solution: Query objects

# app/queries/user_search_query.rb
class UserSearchQuery
  def initialize(relation = User.all)
    @relation = relation
  end

  def call(params)
    @relation
      .then { |r| by_name(r, params[:name]) }
      .then { |r| by_email(r, params[:email]) }
      .then { |r| by_status(r, params[:status]) }
      .then { |r| by_role(r, params[:role]) }
      .then { |r| by_created_date(r, params[:created_from], params[:created_to]) }
      .then { |r| with_minimum_posts(r, params[:min_posts]) }
      .then { |r| order_by(r, params[:sort], params[:direction]) }
  end

  private

  def by_name(relation, name)
    return relation if name.blank?
    relation.where('name ILIKE ?', "%#{name}%")
  end

  def by_email(relation, email)
    return relation if email.blank?
    relation.where('email ILIKE ?', "%#{email}%")
  end

  def by_status(relation, status)
    return relation if status.blank?
    relation.where(status: status)
  end

  def by_role(relation, role)
    return relation if role.blank?
    relation.where(role: role)
  end

  def by_created_date(relation, from, to)
    relation = relation.where('created_at >= ?', from) if from.present?
    relation = relation.where('created_at <= ?', to) if to.present?
    relation
  end

  def with_minimum_posts(relation, min_posts)
    return relation if min_posts.blank?

    relation
      .joins(:posts)
      .group('users.id')
      .having('COUNT(posts.id) >= ?', min_posts)
  end

  def order_by(relation, sort, direction)
    return relation.order(created_at: :desc) if sort.blank?

    direction = direction&.downcase == 'asc' ? :asc : :desc
    relation.order(sort => direction)
  end
end

# Controller
class UsersController < ApplicationController
  def index
    @users = UserSearchQuery.new.call(search_params).page(params[:page])
  end

  private

  def search_params
    params.permit(:name, :email, :status, :role, :created_from, :created_to, :min_posts, :sort, :direction)
  end
end

# More complex query object
class TopPerformersQuery
  def initialize(relation = User.all)
    @relation = relation.active
  end

  def call(time_period: 1.month, limit: 10)
    @relation
      .select(
        'users.*',
        'COUNT(DISTINCT posts.id) as posts_count',
        'COUNT(DISTINCT comments.id) as comments_count',
        'SUM(posts.views_count) as total_views',
        '(COUNT(DISTINCT posts.id) * 10 + COUNT(DISTINCT comments.id) * 2) as score'
      )
      .joins(:posts)
      .left_joins(posts: :comments)
      .where('posts.created_at > ?', time_period.ago)
      .group('users.id')
      .order('score DESC')
      .limit(limit)
  end
end

# Usage
top_users = TopPerformersQuery.new.call(time_period: 1.week, limit: 5)

# ============================================
# PATTERN 5: Policy Objects (Authorization)
# ============================================

# Using Pundit gem

# Gemfile
gem 'pundit'

# app/policies/post_policy.rb
class PostPolicy
  attr_reader :user, :post

  def initialize(user, post)
    @user = user
    @post = post
  end

  def index?
    true  # Anyone can view list
  end

  def show?
    post.published? || user_is_owner_or_admin?
  end

  def create?
    user.present?
  end

  def update?
    user_is_owner_or_admin?
  end

  def destroy?
    user_is_owner_or_admin?
  end

  def publish?
    user_is_owner_or_admin? && post.draft?
  end

  class Scope
    attr_reader :user, :scope

    def initialize(user, scope)
      @user = user
      @scope = scope
    end

    def resolve
      if user&.admin?
        scope.all
      elsif user
        scope.where(published: true).or(scope.where(user: user))
      else
        scope.published
      end
    end
  end

  private

  def user_is_owner_or_admin?
    user.present? && (user == post.user || user.admin?)
  end
end

# Controller
class PostsController < ApplicationController
  def index
    @posts = policy_scope(Post)
  end

  def show
    @post = Post.find(params[:id])
    authorize @post
  end

  def update
    @post = Post.find(params[:id])
    authorize @post

    if @post.update(post_params)
      redirect_to @post
    else
      render :edit
    end
  end
end

# ============================================
# PATTERN 6: Value Objects (Immutable Data)
# ============================================

# Problem: Primitive obsession, mutable data
# Solution: Value objects

# app/values/money.rb
class Money
  include Comparable

  attr_reader :amount, :currency

  def initialize(amount, currency = 'USD')
    @amount = BigDecimal(amount.to_s)
    @currency = currency.to_s.upcase
    freeze  # Make immutable
  end

  def +(other)
    ensure_same_currency!(other)
    Money.new(amount + other.amount, currency)
  end

  def -(other)
    ensure_same_currency!(other)
    Money.new(amount - other.amount, currency)
  end

  def *(multiplier)
    Money.new(amount * multiplier, currency)
  end

  def <=>(other)
    ensure_same_currency!(other)
    amount <=> other.amount
  end

  def to_s
    "#{currency} #{format_amount}"
  end

  def format_amount
    amount.to_f.round(2)
  end

  def zero?
    amount.zero?
  end

  private

  def ensure_same_currency!(other)
    unless currency == other.currency
      raise ArgumentError, "Currency mismatch: #{currency} vs #{other.currency}"
    end
  end
end

# Usage in models
class Product < ApplicationRecord
  def price
    Money.new(read_attribute(:price_cents) / 100.0, price_currency)
  end

  def price=(money)
    if money.is_a?(Money)
      write_attribute(:price_cents, (money.amount * 100).to_i)
      write_attribute(:price_currency, money.currency)
    else
      write_attribute(:price_cents, (money.to_f * 100).to_i)
    end
  end
end

# Usage
product = Product.new
product.price = Money.new(19.99, 'USD')
product.price  # => Money(19.99, USD)
product.price.to_s  # => "USD 19.99"

# Calculations
total = product.price * 2  # => Money(39.98, USD)
discount = total - Money.new(5, 'USD')  # => Money(34.98, USD)

# Address value object
class Address
  attr_reader :street, :city, :state, :zip, :country

  def initialize(street:, city:, state:, zip:, country: 'USA')
    @street = street
    @city = city
    @state = state
    @zip = zip
    @country = country
    freeze
  end

  def full_address
    "#{street}, #{city}, #{state} #{zip}, #{country}"
  end

  def same_city?(other)
    city == other.city && state == other.state && country == other.country
  end

  def ==(other)
    other.is_a?(Address) &&
      street == other.street &&
      city == other.city &&
      state == other.state &&
      zip == other.zip &&
      country == other.country
  end

  alias eql? ==

  def hash
    [street, city, state, zip, country].hash
  end
end

# Store in database as JSON
class User < ApplicationRecord
  def address
    return nil unless address_json

    attrs = JSON.parse(address_json, symbolize_names: true)
    Address.new(**attrs)
  end

  def address=(addr)
    self.address_json = addr.to_json if addr
  end
end

# ============================================
# PATTERN 7: Repository Pattern
# ============================================

# Abstract data access layer

# app/repositories/user_repository.rb
class UserRepository
  def find(id)
    User.find(id)
  end

  def find_by_email(email)
    User.find_by(email: email)
  end

  def all_active
    User.where(status: 'active')
  end

  def create(attributes)
    User.create(attributes)
  end

  def update(user, attributes)
    user.update(attributes)
  end

  def destroy(user)
    user.destroy
  end

  # Complex queries
  def top_contributors(limit: 10)
    User.joins(:posts)
        .group('users.id')
        .order('COUNT(posts.id) DESC')
        .limit(limit)
  end

  def recently_active(since: 1.week.ago)
    User.where('last_seen_at > ?', since)
        .order(last_seen_at: :desc)
  end
end

# Usage in service
class UserStatisticsService
  def initialize(repository: UserRepository.new)
    @repository = repository
  end

  def top_users
    @repository.top_contributors(limit: 5)
  end
end

# Benefits:
# - Easy to test (mock repository)
# - Can swap data sources
# - Centralized query logic

# ============================================
# PATTERN 8: Factory Pattern (Testing)
# ============================================

# app/factories/user_factory.rb
class UserFactory
  def self.build(attributes = {})
    default_attributes.merge(attributes).then do |attrs|
      User.new(attrs)
    end
  end

  def self.create(attributes = {})
    build(attributes).tap(&:save!)
  end

  def self.create_admin
    create(role: 'admin', permissions: %w[read write delete])
  end

  def self.create_with_posts(posts_count: 5)
    create.tap do |user|
      posts_count.times do
        PostFactory.create(user: user)
      end
    end
  end

  private

  def self.default_attributes
    {
      email: "user-#{SecureRandom.hex(4)}@example.com",
      name: "Test User",
      password: "password123"
    }
  end
end

# Or use FactoryBot
# Gemfile (test)
gem 'factory_bot_rails'

# spec/factories/users.rb
FactoryBot.define do
  factory :user do
    sequence(:email) { |n| "user#{n}@example.com" }
    name { "Test User" }
    password { "password123" }

    trait :admin do
      role { 'admin' }
    end

    trait :with_posts do
      transient do
        posts_count { 5 }
      end

      after(:create) do |user, evaluator|
        create_list(:post, evaluator.posts_count, user: user)
      end
    end
  end
end

# Usage
user = FactoryBot.create(:user)
admin = FactoryBot.create(:user, :admin)
user_with_posts = FactoryBot.create(:user, :with_posts, posts_count: 10)

Design Pattern Summary

# When to use each pattern:

# SERVICE OBJECTS - Use when:
# ✓ Complex business logic
# ✓ Multiple model interactions
# ✓ External API calls
# ✓ Multi-step operations
# Example: UserRegistration, OrderCheckout, PaymentProcessing

# DECORATORS - Use when:
# ✓ Presentation logic
# ✓ View-specific formatting
# ✓ HTML generation
# ✓ Keeping views clean
# Example: UserDecorator, ProductDecorator

# FORM OBJECTS - Use when:
# ✓ Complex forms
# ✓ Multiple models
# ✓ Custom validations
# ✓ Virtual attributes
# Example: RegistrationForm, CheckoutForm

# QUERY OBJECTS - Use when:
# ✓ Complex database queries
# ✓ Reusable queries
# ✓ Multiple filters
# ✓ Keeping models clean
# Example: UserSearchQuery, ReportQuery

# POLICY OBJECTS - Use when:
# ✓ Authorization logic
# ✓ Complex permissions
# ✓ Role-based access
# Example: PostPolicy, CommentPolicy

# VALUE OBJECTS - Use when:
# ✓ Immutable data
# ✓ Domain concepts
# ✓ Calculated values
# Example: Money, Address, DateRange

# REPOSITORY PATTERN - Use when:
# ✓ Abstract data access
# ✓ Easy testing
# ✓ Multiple data sources
# Example: UserRepository, ProductRepository

Key Takeaways

Service Objects: Extract complex business logic
Decorators: Keep presentation logic out of models
Form Objects: Handle complex form validations
Query Objects: Encapsulate complex queries
Policy Objects: Centralize authorization
Value Objects: Immutable domain concepts
Repository Pattern: Abstract data access
Follow Rails conventions: Use patterns when they add value
Don't over-engineer: Start simple, add patterns when needed
Test patterns: Patterns make code more testable

Loading...